/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package taini;

import com.mysql.jdbc.Connection;
import java.awt.Frame;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.NClob;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
import taini.koneksi.*;

/**
 *
 * @author Aini
 */
public class query {

     //koneksi.KoneksiAini kon=new KoneksiAini();
    taini.koneksi.KoneksiAini kon = new KoneksiAini();
    String koneksi = "org.gjt.mm.mysql.Driver";
    String database = "jdbc:mysql://localhost:3306/taaini";
    String user = "root";
    String password = "";

public String[][] ambilDokumen() throws SQLException
{
    kon.connectFirst();
    int count = 0;
    String[][] hasil = new String[count][2];

    if (kon.isConnected())
    {
        ResultSet rset1 = kon.executeSelect("select count(*) as c from dokumen");
        if (rset1.next()) {
            count = Integer.parseInt(rset1.getString("c"));
        }
        hasil = new String[count][2];
        int i=0;
        ResultSet rset = kon.executeSelect("select judul,isi from dokumen");
        while (rset.next())
        {
            hasil[i][0] = rset.getString("judul");
            hasil[i][1] = rset.getString("isi");
            i++;
        }
    }
    return hasil;
}


public int maxIDdok(String judul, String isi)
{
        try {
            kon.connectFirst();
 //           Connection connection = DriverManager.getConnection(database,user,password);
            int IDmax = 0;
            //Statement statement = connection.createStatement();
            if (kon.isConnected()) {
                ResultSet rhasil = kon.executeSelect("SELECT MAX( ID_DOK  as MAX FROM DOKUMEN");
                if(rhasil.next())
                    IDmax = Integer.parseInt(rhasil.getString("MAX"));
            String sql = "insert into DOKUMEN (ID_DOK,JUDUL,ISI) values ("+IDmax+",'" + judul + "','" + isi + "');";
            kon.executeUpdate(sql);


            }

            //          statement.executeUpdate(sql);
            //        statement.close();
            return 0;
        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }
        return 0;
}

public String[][] fullDokumen() throws SQLException
{
    kon.connectFirst();
    int count = 0;
    String[][] hasil = new String[count][3];

    if (kon.isConnected())
    {
        ResultSet rset1 = kon.executeSelect("select count(*) as c from dokumen");
        if (rset1.next()) {
            count = Integer.parseInt(rset1.getString("c"));
        }
        hasil = new String[count][3];
        int i=0;
        ResultSet rset = kon.executeSelect("select ID_DOK,judul,isi from dokumen");
        while (rset.next())
        {
            
            hasil[i][0] = rset.getString("ID_DOK");
            hasil[i][1] = rset.getString("judul");
            hasil[i][2] = rset.getString("isi");
            i++;
        }
    }
    return hasil;
}


public LinkedList<String> ambilKategori()
{
            LinkedList<String> Kategori = new LinkedList<String>();

        try {
            kon.connectFirst();
            int count = 0;
            String[][] keywords = new String[count][2];
            int i = 0;
            if(kon.isConnected())
            {
            ResultSet rset = kon.executeSelect("SELECT D.KELAS AS KATEGORI, T.NAMA_TERM AS KEYWORDS FROM DOKUMEN D, VEKTOR V, TERMS T WHERE D.ID_DOK = V.ID_DOK AND V.ID_TERM = T.ID_TERM AND V.FREKUENSI >2 ORDER BY D.KELAS ASC");
            while(rset.next())
            {
                keywords[i][0] = rset.getString("KATEGORI");
                keywords[i][1] = rset.getString("KEYWORDS");


            }
            }


            return Kategori;
        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }
        return Kategori;
}

public LinkedList<String> ambilStoplist()
{
        LinkedList<String> stopList = new LinkedList<String>();
        try {
            kon.connectFirst();
            int count = 0;
            String[][] hasil = new String[count][3];

            if (kon.isConnected()) {
                ResultSet rset1 = kon.executeSelect("select count(*) as c from stoplist");
                if (rset1.next()) {
                    count = Integer.parseInt(rset1.getString("c"));
                }
                hasil = new String[count][1];
                int i = 0;
                ResultSet rset = kon.executeSelect("select stopword from stoplist");
                while (rset.next()) {
                    hasil[i][0] = rset.getString("stopword");
                    stopList.add(hasil[i][0]);
                    i++;
                }
            }

        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }
        return stopList;
}

public ResultSet executeSQL(String sql)
{
    ResultSet rs = new ResultSet() {

            public boolean next() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void close() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean wasNull() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public String getString(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean getBoolean(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public byte getByte(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public short getShort(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public int getInt(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public long getLong(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public float getFloat(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public double getDouble(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public byte[] getBytes(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Date getDate(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Time getTime(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Timestamp getTimestamp(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public InputStream getAsciiStream(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public InputStream getUnicodeStream(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public InputStream getBinaryStream(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public String getString(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean getBoolean(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public byte getByte(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public short getShort(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public int getInt(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public long getLong(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public float getFloat(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public double getDouble(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public byte[] getBytes(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Date getDate(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Time getTime(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Timestamp getTimestamp(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public InputStream getAsciiStream(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public InputStream getUnicodeStream(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public InputStream getBinaryStream(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public SQLWarning getWarnings() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void clearWarnings() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public String getCursorName() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public ResultSetMetaData getMetaData() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Object getObject(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Object getObject(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public int findColumn(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Reader getCharacterStream(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Reader getCharacterStream(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean isBeforeFirst() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean isAfterLast() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean isFirst() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean isLast() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void beforeFirst() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void afterLast() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean first() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean last() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public int getRow() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean absolute(int row) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean relative(int rows) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean previous() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void setFetchDirection(int direction) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public int getFetchDirection() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void setFetchSize(int rows) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public int getFetchSize() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public int getType() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public int getConcurrency() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean rowUpdated() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean rowInserted() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean rowDeleted() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNull(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBoolean(int columnIndex, boolean x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateByte(int columnIndex, byte x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateShort(int columnIndex, short x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateInt(int columnIndex, int x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateLong(int columnIndex, long x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateFloat(int columnIndex, float x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateDouble(int columnIndex, double x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateString(int columnIndex, String x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBytes(int columnIndex, byte[] x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateDate(int columnIndex, Date x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateTime(int columnIndex, Time x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateObject(int columnIndex, Object x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNull(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBoolean(String columnLabel, boolean x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateByte(String columnLabel, byte x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateShort(String columnLabel, short x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateInt(String columnLabel, int x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateLong(String columnLabel, long x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateFloat(String columnLabel, float x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateDouble(String columnLabel, double x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateString(String columnLabel, String x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBytes(String columnLabel, byte[] x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateDate(String columnLabel, Date x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateTime(String columnLabel, Time x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateObject(String columnLabel, Object x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void insertRow() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateRow() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void deleteRow() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void refreshRow() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void cancelRowUpdates() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void moveToInsertRow() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void moveToCurrentRow() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Statement getStatement() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Ref getRef(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Blob getBlob(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Clob getClob(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Array getArray(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Ref getRef(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Blob getBlob(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Clob getClob(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Array getArray(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Date getDate(int columnIndex, Calendar cal) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Date getDate(String columnLabel, Calendar cal) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Time getTime(int columnIndex, Calendar cal) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Time getTime(String columnLabel, Calendar cal) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public URL getURL(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public URL getURL(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateRef(int columnIndex, Ref x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateRef(String columnLabel, Ref x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBlob(int columnIndex, Blob x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBlob(String columnLabel, Blob x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateClob(int columnIndex, Clob x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateClob(String columnLabel, Clob x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateArray(int columnIndex, Array x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateArray(String columnLabel, Array x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public RowId getRowId(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public RowId getRowId(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateRowId(int columnIndex, RowId x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateRowId(String columnLabel, RowId x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public int getHoldability() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean isClosed() throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNString(int columnIndex, String nString) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNString(String columnLabel, String nString) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public NClob getNClob(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public NClob getNClob(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public SQLXML getSQLXML(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public SQLXML getSQLXML(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public String getNString(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public String getNString(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Reader getNCharacterStream(int columnIndex) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public Reader getNCharacterStream(String columnLabel) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateClob(int columnIndex, Reader reader) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateClob(String columnLabel, Reader reader) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNClob(int columnIndex, Reader reader) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public void updateNClob(String columnLabel, Reader reader) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public <T> T unwrap(Class<T> iface) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public boolean isWrapperFor(Class<?> iface) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }

            public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
                throw new UnsupportedOperationException("Not supported yet.");
            }
        };
        try {
            kon.connectFirst();
            if (kon.isConnected())
            {
                rs = kon.executeSelect(sql);
            }
        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }
    return rs;
}

    String[][] ambilDokumenSemua() {

         int count = 0;
        String[][] hasil = new String[count][3];
        try {
            kon.connectFirst();


            if (kon.isConnected()) {
                ResultSet rset1 = kon.executeSelect("select count(*) as c from dokumen");
                if (rset1.next()) {
                    count = Integer.parseInt(rset1.getString("c"));
                }
                hasil = new String[count][6];
                int i = 0;
                ResultSet rset = kon.executeSelect("select d.ID_DOK,d.judul,d.isi,d.tanggal, t.topik,k.nama_kategori " +
                        "from dokumen d, topik t, dok_kat dk, kategori k " +
                        "where d.id_dok = dk.id_dok AND dk.id_kategori = k.id_kategori AND d.id_topik = t.id_topik");
                while (rset.next()) {
                    hasil[i][0] = rset.getString(1);
                    hasil[i][1] = rset.getString(2);
                    hasil[i][2] = rset.getString(3);
                    hasil[i][3] = rset.getString(4);
                    hasil[i][4] = rset.getString(5);
                    hasil[i][5] = rset.getString(6);
                    i++;
                }
            }

        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }

                    return hasil;
    }

    void deleteDok(String idHapus) {
        try {
            kon.connectFirst();
            int id = Integer.parseInt(idHapus);
            String delete = "DELETE FROM dokumen where id_dok = " + id + " ";
           
            kon.executeUpdate(delete);
            String deleteVektor = "DELETE FROM VEKTOR WHERE ID_DOK ="+id+" ";
            kon.executeUpdate(deleteVektor);
            String deleteDokKat = "DELETE FROM DOK_KAT WHERE ID_DOK = "+id+"";
            kon.executeUpdate(deleteDokKat);

            String selectTopik = "SELECT T.ID_TOPIK FROM TOPIK T " +
                    "WHERE T.ID_TOPIK NOT IN" +
                    "(SELECT D.ID_TOPIK FROM TOPIK T, DOKUMEN D WHERE D.ID_TOPIK = T.ID_TOPIK)";
            ResultSet rs = kon.executeSelect(selectTopik);
            String deleteTopik="";
            while(rs.next())
            {
            deleteTopik = "DELETE FROM TOPIK WHERE ID_TOPIK = "+rs.getString(1)+"";
            kon.executeUpdate(deleteTopik);
            deleteTopik = "";
            }
            String deleteKatkey = "DELETE FROM KAT_KEY WHERE ID_KEY ="+id+"";
            kon.executeUpdate(deleteKatkey);


        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }

    }

    void deleteKata(String kata) {
        try {
            kon.connectFirst();

            String delete = "DELETE FROM KAMUS where kata = '" + kata + "'";
             kon.executeUpdate(delete);
        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    void insertKata(String kata) {

         try {
            kon.connectFirst();
            String select = "SELECT kata FROM KAMUS where kata = '" + kata + "'";
             ResultSet rs = kon.executeSelect(select);
             if(rs.next())
             {
             JOptionPane.showMessageDialog(new Frame(), "Kata "+kata+" sudah ada di dalam kamus");
             }
             else{
            String insert = "INSERT INTO KAMUS values ('" + kata + "')";
             kon.executeUpdate(insert);
             JOptionPane.showMessageDialog(new Frame(), "Kata "+kata+" berhasil dimasukkan");
             }
             
        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }

    }

    void insertStoplist(String stopword) {
        try {
            kon.connectFirst();
            //insert into keywords (keywords) values ('"+keys+"')
            String insert = "INSERT INTO stoplist values ('" + stopword + "')";
             kon.executeUpdate(insert);
        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    void deleteStoplist(String kata) {
        try {
            kon.connectFirst();
            String delete = "DELETE FROM STOPLIST where STOPWORD = '" + kata + "'";
            kon.executeUpdate(delete);
        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    int getMax() {

                   int IDdok = 0;

        try {
            kon.connectFirst();
           String hasilID = "SELECT MAX( ID_DOK)  as MAX FROM DOKUMEN";
           ResultSet rs = kon.executeSelect(hasilID);
           while(rs.next())
           {
           IDdok = Integer.parseInt(rs.getString(1));
           }
        } catch (SQLException ex) {
            Logger.getLogger(query.class.getName()).log(Level.SEVERE, null, ex);
        }

        return IDdok;
    }

}
